package com.hn.controller;

import com.github.pagehelper.PageInfo;
import com.hn.Util.StringUtil;
import com.hn.pojo.Banji;
import com.hn.pojo.Course;
import com.hn.pojo.SC;
import com.hn.pojo.Student;
import com.hn.service.*;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletResponse;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

/**
 * @作者 : wangchangdian
 * @创建时间 : 2019/3/26 - 23:27
 */
@Controller
@RequestMapping("ss")
public class SchoolSystemContrller {
    @Autowired
    StudentService studentService;
    @Autowired
    GuanXiService guanXiService;
    @Autowired
    CourseService courseService;
    @Autowired
    BanjiService banjiService;
    @Autowired
    SCService scService;
    @Autowired
    BdMapService bdMapService;


/*    @ResponseBody
    @PostMapping(value = "saveCover.html", produces = "application/json;charset=utf-8")
    public String saveCover(JSONObject cover){
        // rep.setContentType("text/html;charset=utf-8");
        BdMap bdMap = new BdMap();
        bdMap.setCoveroord(cover);
        bdMapService.saveMap(bdMap);


        return "ok";
    }*/

    //学生选课(在用)
    @ResponseBody
    @GetMapping(value = "StuChoice.html", produces = "application/json;charset=utf-8")
    public String StuChoice(String CouId, String StuId, HttpServletResponse rep) throws InterruptedException {
        rep.setContentType("text/html;charset=utf-8");
        JSONObject resource = new JSONObject();
        JSONArray array = new JSONArray();
        //去重
        List<SC> byIdCous = scService.findByIdCous(Integer.parseInt(StuId));
        for (SC sc : byIdCous) {
            if (sc.getCid() == Integer.parseInt(CouId)) {
                scService.deleSC(Integer.parseInt(StuId), Integer.parseInt(CouId));
            }
        }
        //把stuid和couid插入sc
        scService.insertSC(Integer.parseInt(StuId), Integer.parseInt(CouId));
        //获取所有课程
        List<Course> allCou = courseService.findAllCou();

        //Thread.sleep(2000);

        //获取学生所有的课程，就是获取当前学生所有的cid
        List<SC> StuCous = scService.findByIdCous(Integer.parseInt(StuId));
        //遍历所有课程
        for (Course course : allCou) {//遍历所有课程
            Boolean State = false; //定义一个初始值为false的变量
            for (SC sc : StuCous) {//遍历学生所有的cid(就是学生的所有课程)
                //如果学生的课程在课程表中存在，就把课程表的状态设置为true,这样一来，已选的课程就会对学生隐藏了
                if (sc.getCid() == course.getID()) {
                    State = true;//把true覆盖state,使此时处于false状态的state表为true

                    //注意：在未跳出本次循环之前 ，上级循环中的数据不变，也就是说，
                    // course.getID()，还是原来的值，考虑到cid和couid的唯一性因此，
                    //也就是说，本级循环至结束，只有一次sc.getCid()==course.getID()的情况。
                    //等到以及循环的值再次发生变化时，本级循环才能才发生sc.getCid()==course.getID()的情况
                    //每当发生一次sc.getCid()==course.getID()的情况，State都会被改变，但直至本级循环结束，state也只会被改变一次
                    //本级循环结束后，就会立即装载一次数据，然后，一级循环的值才再次变化

                }//跳出判断
            }//跳出本级循环，进入上级循环
            JSONObject object = new JSONObject();
            object.put("CouName", course.getCouName());
            object.put("CouId", course.getID());
            object.put("state", State);//把改变后的State封装到当前不需要对当前学生显示的课程
            //装载对象
            array.add(object);

        }
        //返回整个课表，但是里面有ture的，也有false的，因此，会自动把ture的隐藏掉
        resource.put("data", array);
        return resource.toString();

    }

    //学生退程(在用)
    @ResponseBody
    @GetMapping(value = "StuDeleCou.html", produces = "application/json;charset=utf-8")
    public String StuDeleCou(String CouId, String StuId, HttpServletResponse rep) {
        rep.setContentType("text/html;charset=utf-8");
        JSONObject resource = new JSONObject();
        JSONArray array = new JSONArray();
        //把sc中的课删掉
        scService.deleSC(Integer.parseInt(StuId), Integer.parseInt(CouId));

        //传入sid和cid
        //获取所有课程
        List<Course> allCou = courseService.findAllCou();
        //获取学生所有的课程，就是获取当前学生所有的cid
        List<SC> StuCous = scService.findByIdCous(Integer.parseInt(StuId));
        //遍历所有课程
        for (Course course : allCou) {//遍历所有课程
            Boolean State = false; //定义一个初始值为false的变量
            for (SC sc : StuCous) {//遍历学生所有的cid(就是学生的所有课程)
                //如果学生的课程在课程表中存在，就把课程表的状态设置为true,这样一来，已选的课程就会对学生隐藏了
                if (sc.getCid() == course.getID()) {
                    State = true;//把true覆盖state,使此时处于false状态的state表为true

                    //注意：在未跳出本次循环之前 ，上级循环中的数据不变，也就是说，
                    // course.getID()，还是原来的值，考虑到cid和couid的唯一性因此，
                    //也就是说，本级循环至结束，只有一次sc.getCid()==course.getID()的情况。
                    //等到以及循环的值再次发生变化时，本级循环才能才发生sc.getCid()==course.getID()的情况
                    //每当发生一次sc.getCid()==course.getID()的情况，State都会被改变，但直至本级循环结束，state也只会被改变一次
                    //本级循环结束后，就会立即装载一次数据，然后，一级循环的值才再次变化

                }//跳出判断
            }//跳出本级循环，进入上级循环
            JSONObject object = new JSONObject();
            object.put("CouName", course.getCouName());
            object.put("CouId", course.getID());
            object.put("state", State);//把改变后的State封装到当前不需要对当前学生显示的课程
            //装载对象
            array.add(object);

        }

        //打印到页面
        resource.put("data", array);
        return resource.toString();

    }

    //课程列表(在用)
    @GetMapping(value = "couList.html", produces = "application/json;charset=utf-8")
    @ResponseBody
    public String couList(String StuId, String pageCode, String pageSize, HttpServletResponse response) {
        response.setContentType("text/plain;charset=UTF-8");
        JSONObject resource = new JSONObject();
        JSONArray array = new JSONArray();
        //获取所有课程
        PageInfo<Course> CouPageInfo = courseService.findAllCou(Integer.parseInt(pageCode), Integer.parseInt(pageSize));
        List<Course> allCou = CouPageInfo.getList();//取出课程数据
        int pageNum = CouPageInfo.getPageNum();//取出当前页码
        int PageSize = CouPageInfo.getPageSize();//取出当前条数
        int total = CouPageInfo.getNavigatePages();//取出当前总条数
        //根据学生当前的id对比SC表中的Cid，查询学生所有的课名(  //排除sc中state=0的字段,只显示1的)
        List<SC> scCids = scService.findByIdCous(Integer.parseInt(StuId));

        for (Course course : allCou) {//遍历所有课程
            Boolean State = false; //定义一个初始值为false的变量
            for (SC sc : scCids) {//遍历学生所有的cid(就是学生的所有课程)
                //如果学生的课程在课程表中存在，就把课程表的状态设置为true,这样一来，已选的课程就会对学生隐藏了
                if (sc.getCid() == course.getID()) {
                    State = true;//把true覆盖state,使此时处于false状态的state表为true

                    //注意：在未跳出本次循环之前 ，上级循环中的数据不变，也就是说，
                    // course.getID()，还是原来的值，考虑到cid和couid的唯一性因此，
                    //也就是说，本级循环至结束，只有一次sc.getCid()==course.getID()的情况。
                    //等到以及循环的值再次发生变化时，本级循环才能才发生sc.getCid()==course.getID()的情况
                    //每当发生一次sc.getCid()==course.getID()的情况，State都会被改变，但直至本级循环结束，state也只会被改变一次
                    //本级循环结束后，就会立即装载一次数据，然后，一级循环的值才再次变化

                }//跳出判断
            }//跳出本级循环，进入上级循环
            JSONObject object = new JSONObject();
            object.put("CouName", course.getCouName());
            object.put("CouId", course.getID());
            object.put("state", State);//把改变后的State封装到当前不需要对当前学生显示的课程
            //装载对象
            array.add(object);

        }
        //返回整个课表，但是里面有ture的，也有false的，因此，会自动把ture的隐藏掉

        resource.put("pageNum", CouPageInfo.getPageNum());
        resource.put("pageSize", CouPageInfo.getPageSize());
        resource.put("total", CouPageInfo.getNavigatePages());
        resource.put("data", array);
        return resource.toString();

    }

    //获取学生已选的课（在用）
    @GetMapping(value = "UpStuCou.html", produces = "application/json;charset=utf-8")
    @ResponseBody
    public String UpStuCou(String StuId, HttpServletResponse response) {
        response.setContentType("text/plain;charset=UTF-8");
        JSONObject resource = new JSONObject();
        JSONArray array = new JSONArray();
        //获取所有课程
        List<Course> allCou = courseService.findAllCou();
        //查询学生所有课程
        List<SC> byIdCous = scService.findByIdCous(Integer.parseInt(StuId));
        //把couid不等于cid的过滤掉
        for (Course course : allCou) {
            for (SC sc : byIdCous) {
                if (course.getID() == sc.getCid()) {
                    JSONObject object = new JSONObject();
                    object.put("CouId", course.getID());
                    object.put("CouName", course.getCouName());
                    array.add(object);

                }

            }

        }

        resource.put("data", array);
        return resource.toString();
    }

    //学生列表(在用)
    @GetMapping(value = "stuList.html", produces = "application/json;charset=utf-8")
    @ResponseBody
    public String stuList(String pageCode, String pageSize, HttpServletResponse response) {
        response.setContentType("text/plain;charset=UTF-8");
        JSONObject studentJSON = new JSONObject();
        JSONArray stuarray = new JSONArray();

        //查询学生表
        PageInfo<Student> allStuPage = studentService.findAllStuPage(Integer.parseInt(pageCode), Integer.parseInt(pageSize));//收到结果集
        List<Student> allStu = allStuPage.getList();//从结果集中拿出学生集合

        int pageNum = allStuPage.getPageNum();//取出页数
        int PageSize = allStuPage.getPageSize();//取出条数
        long total = allStuPage.getTotal();//取出总条数

        /* PageInfo{pageNum=1, pageSize=4, size=4, startRow=1, endRow=4, total=6, pages=2,
        list=Page{count=true, pageNum=1, pageSize=4, startRow=0, endRow=4, total=6, pages=2, reasonable=true, pageSizeZero=false}
        [com.hn.pojo.Student@6fd65799, com.hn.pojo.Student@20a1f4f3, com.hn.pojo.Student@683f7a7d, com.hn.pojo.Student@27de0efa],
         prePage=0, nextPage=2, isFirstPage=true, isLastPage=false, hasPreviousPage=false, hasNextPage=true, navigatePages=8,
          navigateFirstPage=1, navigateLastPage=2, navigatepageNums=[1, 2]}*/
        for (Student student : allStu) {
            JSONObject stujson = new JSONObject();
            stujson.put("ID", student.getID());
            stujson.put("StuName", student.getStuName());
            stujson.put("Sex", student.getSex());
            stujson.put("StuAge", student.getStuAge());
            stujson.put("PassWord", student.getPassWord());
            stujson.put("StuDate", StringUtil.getLenStrin(String.valueOf(student.getCreateDate()), 0, 10));

            //每个学生都携带时间差（学生创建的时间和此刻的时间差，单位：秒）
            long DateJet = Long.parseLong(StringUtil.getNumStrin(String.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()))))
                    - Long.parseLong(StringUtil.getLenStrin(StringUtil.getNumStrin(String.valueOf(student.getCreateDate())), 0, 14));
            stujson.put("DateJet", String.valueOf(DateJet));

            stuarray.add(stujson);
        }

        //可以把stuarray存入狱中
        studentJSON.put("pageNum", allStuPage.getPageNum());//当前页
        studentJSON.put("pageSize", allStuPage.getPageSize());//当前条数
        studentJSON.put("total", allStuPage.getTotal());//当前总条数
        studentJSON.put("data", stuarray);//学生数据

        return studentJSON.toString();

    }

    //增加学生（在用）
    @ResponseBody
    @RequestMapping(value = "addStu.html")
    public String addStu(String StuName, String StuAge, String StuSex) {
        String sex = "女";

        if (StuName.equals("") || StuName == null) {
            return "不能为空！";
        }
        if (StuSex.equals("1")) {
            sex = "男";

        }

        //新建一个学生档案
        Student student = new Student();
        student.setStuName(StuName);
        student.setStuAge(Integer.parseInt(StuAge));
        //刚入学的学生的默认密码
        student.setPassWord("123456");
        student.setSex(sex);

        //获得系统实时时间
        String nowTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        Timestamp rowTime = Timestamp.valueOf(nowTime);//把时间转换?
        //把当前的时间注入学生信息
        student.setCreateDate(rowTime);
        if (student != null) {
            studentService.addStu(student);//保存 学生
        }

/*
        //取出某个学生
        Student stu = studentService.findStu(57);
        //学生时间
        long StuDate = Long.parseLong(StringUtil.getLenStrin(StringUtil.getNumStrin(String.valueOf(stu.getCreateDate())), 0, 14));
        //系统时间
        long nowdate = Long.parseLong(StringUtil.getNumStrin(String.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()))));

        //时差（单位：秒）
       long cha = nowdate - StuDate;

        return "时差"+cha+"秒";*/

        return "添加成功";

    }

    //删除学生（在用）
    @ResponseBody
    @RequestMapping(value = "deleteStu.html")
    public String deleteStu(String StuId) {

        if (!StuId.equals("0") || StuId != null) {
            studentService.deleteStu(Integer.parseInt(StuId));
            //删除学生的同时，删除其所有课程
            scService.deleSCAll(Integer.parseInt(StuId));
        }

        return "OK";
    }

    @ResponseBody
    @GetMapping(value = "findLikeStus.html",produces = "application/json;charset=utf-8")
    public String findLikeStus(String content, String pageCode, String pageSize, HttpServletResponse response) {
        response.setContentType("text/plain;charset=UTF-8");
        JSONObject studentJSON = new JSONObject();
        JSONArray stuarray = new JSONArray();
        List<Student> allStu = null;
        int pageNum = 0;
        int PageSize = 0;
        long total = 0;
        //如果搜索内容为空(查询全部)
        if (content == null || content.equals("")) {
            PageInfo<Student> allStuPage = studentService.findAllStuPage(Integer.parseInt(pageCode), Integer.parseInt(pageSize));
            allStu = allStuPage.getList();//从结果集中拿出学生集合
            pageNum = allStuPage.getPageNum();//取出页数
            PageSize = allStuPage.getPageSize();//取出条数
            total = allStuPage.getTotal();//取出总条数
        }
        //如果搜索内容不为空（按条件查）
        if (content != null || !content.equals("")) {
            PageInfo<Student> allStuPage = studentService.findLikeStu(content, Integer.parseInt(pageCode), Integer.parseInt(pageSize));
            allStu = allStuPage.getList();//从结果集中拿出学生集合
            pageNum = allStuPage.getPageNum();//取出页数
            PageSize = allStuPage.getPageSize();//取出条数
            total = allStuPage.getTotal();//取出总条数
        }

        for (Student student : allStu) {
            JSONObject stujson = new JSONObject();
            stujson.put("ID", student.getID());
            stujson.put("StuName", student.getStuName());
            stujson.put("Sex", student.getSex());
            stujson.put("StuAge", student.getStuAge());
            stujson.put("PassWord", student.getPassWord());
            stujson.put("StuDate", StringUtil.getLenStrin(String.valueOf(student.getCreateDate()), 0, 10));

            //每个学生都携带时间差（学生创建的时间和此刻的时间差，单位：秒）
            long DateJet = Long.parseLong(StringUtil.getNumStrin(String.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()))))
                    - Long.parseLong(StringUtil.getLenStrin(StringUtil.getNumStrin(String.valueOf(student.getCreateDate())), 0, 14));
            stujson.put("DateJet", String.valueOf(DateJet) + "秒");
            stuarray.add(stujson);
        }

        //可以把stuarray存入狱中
        studentJSON.put("pageNum", pageNum);//当前页
        studentJSON.put("pageSize", PageSize);//当前条数
        studentJSON.put("total", total);//当前总条数
        studentJSON.put("data", stuarray);//学生数据

        return studentJSON.toString();

    }

    //增加课程（完）
    @ResponseBody
    @RequestMapping(value = "addCou.html")
    public String addCou(int couid, String couname) {

        //新建一个课程信息
        Course course = new Course();
        course.setID(couid);
        course.setCouName(couname);
        //截获当前对象的couid
        int guanxi = course.getID();
        //保存课程
        courseService.createCou(course);
        //将学生id插入课程表sid中,并且如果选课失败,则不插入
        // guanXiService.insertInfo(0, guanxi, 0, 0);
        return "success";

    }

    //增加班级（完）
    @ResponseBody
    @RequestMapping(value = "creBanji.html")
    public String creBanji(int bjcode, String bjgrade, String bjname) {
        //新建一个班级信息档案
        Banji banji = new Banji();
        banji.setBjcode(bjcode);
        banji.setBjname(bjname);
        banji.setBjgrade(bjgrade);

        //截获当前对象的主键
        int guanxi = banji.getBjcode();
        //把主键值插入到“guanxi”表的外键外键中
        // guanXiService.insertInfo(0, 0, guanxi, 0);

        banjiService.addBanji(banji);

        return "zengjiachenggong";

    }

    //学生选班（完）
    @ResponseBody
    @RequestMapping(value = "stuPickbj.html")
    public String stuPickBj(HttpServletResponse rep, int ID, String bjname) {

        rep.setContentType("text/html;charset=utf-8");

        //获取学生对象
        Student stu = studentService.findStu(ID);
        //调用获取banji的接口
        List<Banji> allbanji = banjiService.findAllbanji();
        Course course1 = new Course();
        //遍历allbanji集合
        for (Banji banji : allbanji) {
            //果如遍历到的banji名字和学生需要的课程 一致，则进入
            if (banji.getBjname().equals(bjname)) {
                //调用接口，将bjcode存入学生表bid
                int bid = banji.getBjcode();
                //  stu.setBid(bid);//
                //将banji的code存入到当前学生的bid中,修改条件是当前学生的id
                //   studentService.editStu(stu);//修改条件：当前Cou对象自身携带的主键id

            }
        }

        //选择课名

        //将学生当前的sid存入当前课名对应的sid中

        return "选班成功";
    }

    //得到传进来的学生id，保存 方法一
    /*@GetMapping(value = "getId.html", produces = "application/json;charset=utf-8")
    @ResponseBody
    public String getId(HttpServletRequest request,String data) {
        request.getSession().setAttribute("suid",data);
        return "/ss/xuankefrom.html";
    }*/

}